Asymptotic Analysis of Self-Adjusting Contraction Trees

In this report, we analyze the asymptotic efficiency of self-adjusting contraction trees proposed as part of the Slider project [2, 3]. Self-adjusting contraction trees are used for incremental computation [1, 4, 5, 8]. Our analysis extends the asymptotic efficiency analysis of Incoop [6, 7]. We consider two different runs: the initial run of an Slider computation, where we perform a computation with some input I, and a second run for dynamic update where we change the input from I to I′ and perform the same computation with the new input. In the common case, we perform a single initial run followed by many dynamic updates. For the initial run, we define the overhead as the slowdown of Slider compared to a conventional implementation of MapReduce such as with Hadoop. We show that the overhead depends on communication costs and, if these are independent of the input size, which they often are, then it is also constant. Our experiment evaluation confirms that the overhead is relatively small. We show that dynamic updates are dominated by the time it takes to execute fresh tasks that are affected by the changes to the input data, which, for a certain class of computations and small changes, is logarithmic in the size of the input. In the analysis, we use the following terminology to refer to the three different types of computational tasks that form an Slider computation: Map tasks, Self-adjusting balanced tree (applications of the Combiner function for three different modes of operation for sliding-window computations), and Reduce tasks. Our bounds depend on the total number of map tasks, written NM, and the total number of reduce tasks written NR. In addition, we also take in account the total number of stages in self-adjusting balanced tree, denoted as NC. We write ni and nO to denote the total size of the input and output respectively, nm to denote the total number of key-value pairs output by the Map phase, and nmk to denote the set of distinct keys emitted by the Map phase. The number of stages in self-adjusting balanced tree is a property of sliding-window computation mode: append-only (NCA = O(nmk)), fixed-width window slides (NCF = O(nmk · ⌈log2(buckets)⌉)), and variable-width window slides((NCV) = ⌈O(nmk · log2(NM)⌉)). For our time bounds, we will additionally assume that each Map, Combine, and Reduce function performs work that is asymptotically linear in the size of their inputs. Furthermore, we will assume that the Combine function is monotonic, i.e., it produces an output that is no larger than its input. This assumption is satisfied in most applications, because Combiners often reduce the size of the data (e.g., a Combine function to compute the sum of values takes multiple values and outputs a single value).